/*** BNFC-Generated Visitor Traversal Skeleton. ***/
/* This traverses the abstract syntax tree.
   To use, copy Skeleton.h and Skeleton.c to
   new files. */

#include "Skeleton.h"

void visitProgram(Program _p_)
{
  switch(_p_->kind)
  {
  case is_Progr:
    /* Code for Progr Goes Here */
    visitStatement(_p_->u.progr_.statement_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Program!\n");
    exit(1);
  }
}

void visitStatement(Statement _p_)
{
  switch(_p_->kind)
  {
  case is_Stmt:
    /* Code for Stmt Goes Here */
    visitQuery(_p_->u.stmt_.query_);
    visitSc(_p_->u.stmt_.sc_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Statement!\n");
    exit(1);
  }
}

void visitQuery(Query _p_)
{
  switch(_p_->kind)
  {
  case is_Qry:
    /* Code for Qry Goes Here */
    visitSelect(_p_->u.qry_.select_);
    visitSpecifier(_p_->u.qry_.specifier_);
    visitProjection(_p_->u.qry_.projection_);
    visitFrom(_p_->u.qry_.from_);
    visitVariable_declaration(_p_->u.qry_.variable_declaration_);
    visitOptional_where_clause(_p_->u.qry_.optional_where_clause_);
    visitOptional_group_by_clause(_p_->u.qry_.optional_group_by_clause_);
    visitOptional_having_clause(_p_->u.qry_.optional_having_clause_);
    visitOptional_order_by_clause(_p_->u.qry_.optional_order_by_clause_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Query!\n");
    exit(1);
  }
}

void visitNested_query(Nested_query _p_)
{
  switch(_p_->kind)
  {
  case is_NQry:
    /* Code for NQry Goes Here */
    visitQuery(_p_->u.nqry_.query_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Nested_query!\n");
    exit(1);
  }
}

void visitSpecifier(Specifier _p_)
{
  switch(_p_->kind)
  {
  case is_Nospe:
    /* Code for Nospe Goes Here */
    break;
  case is_Distn:
    /* Code for Distn Goes Here */
    visitDistinct(_p_->u.distn_.distinct_);
    visitSpecifier(_p_->u.distn_.specifier_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Specifier!\n");
    exit(1);
  }
}

void visitListProjection(ListProjection listprojection)
{
  while(listprojection != 0)
  {
    /* Code For ListProjection Goes Here */
    visitProjection(listprojection->projection_);
    listprojection = listprojection->listprojection_;
  }
}

void visitProjection(Projection _p_)
{
  switch(_p_->kind)
  {
  case is_Parprj:
    /* Code for Parprj Goes Here */
    visitProjection(_p_->u.parprj_.projection_);
    break;
  case is_Strprj:
    /* Code for Strprj Goes Here */
    break;
  case is_Refprj:
    /* Code for Refprj Goes Here */
    visitReference(_p_->u.refprj_.reference_);
    break;
  case is_Idprj:
    /* Code for Idprj Goes Here */
    visitIdentifier(_p_->u.idprj_.identifier_);
    visitReference(_p_->u.idprj_.reference_);
    break;
  case is_Asprj:
    /* Code for Asprj Goes Here */
    visitReference(_p_->u.asprj_.reference_);
    visitAs(_p_->u.asprj_.as_);
    visitIdentifier(_p_->u.asprj_.identifier_);
    break;
  case is_Plusprj:
    /* Code for Plusprj Goes Here */
    visitProjection(_p_->u.plusprj_.projection_1);
    visitProjection(_p_->u.plusprj_.projection_2);
    break;
  case is_Minprj:
    /* Code for Minprj Goes Here */
    visitProjection(_p_->u.minprj_.projection_1);
    visitProjection(_p_->u.minprj_.projection_2);
    break;
  case is_Mulprj:
    /* Code for Mulprj Goes Here */
    visitProjection(_p_->u.mulprj_.projection_1);
    visitProjection(_p_->u.mulprj_.projection_2);
    break;
  case is_Divprj:
    /* Code for Divprj Goes Here */
    visitProjection(_p_->u.divprj_.projection_1);
    visitProjection(_p_->u.divprj_.projection_2);
    break;
  case is_Modprj:
    /* Code for Modprj Goes Here */
    visitProjection(_p_->u.modprj_.projection_1);
    visitMod(_p_->u.modprj_.mod_);
    visitProjection(_p_->u.modprj_.projection_2);
    break;
  case is_Refprjtw:
    /* Code for Refprjtw Goes Here */
    visitReference(_p_->u.refprjtw_.reference_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Projection!\n");
    exit(1);
  }
}

void visitReference(Reference _p_)
{
  switch(_p_->kind)
  {
  case is_Colref:
    /* Code for Colref Goes Here */
    visitColumn_reference(_p_->u.colref_.column_reference_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Reference!\n");
    exit(1);
  }
}

void visitRererence(Rererence _p_)
{
  switch(_p_->kind)
  {
  case is_Funcref:
    /* Code for Funcref Goes Here */
    visitFunction_reference(_p_->u.funcref_.function_reference_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Rererence!\n");
    exit(1);
  }
}

void visitColumn_reference(Column_reference _p_)
{
  switch(_p_->kind)
  {
  case is_Name:
    /* Code for Name Goes Here */
    visitIdentifier(_p_->u.name_.identifier_);
    break;
  case is_Namenst:
    /* Code for Namenst Goes Here */
    visitColumn_reference(_p_->u.namenst_.column_reference_);
    visitDot(_p_->u.namenst_.dot_);
    visitIdentifier(_p_->u.namenst_.identifier_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Column_reference!\n");
    exit(1);
  }
}

void visitDot(Dot _p_)
{
  switch(_p_->kind)
  {
  case is_Dot:
    /* Code for Dot Goes Here */
    break;
  case is_Ptr:
    /* Code for Ptr Goes Here */
    visitPointer(_p_->u.ptr_.pointer_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Dot!\n");
    exit(1);
  }
}

void visitListVariable_declaration(ListVariable_declaration listvariable_declaration)
{
  while(listvariable_declaration != 0)
  {
    /* Code For ListVariable_declaration Goes Here */
    visitVariable_declaration(listvariable_declaration->variable_declaration_);
    listvariable_declaration = listvariable_declaration->listvariable_declaration_;
  }
}

void visitVariable_declaration(Variable_declaration _p_)
{
  switch(_p_->kind)
  {
  case is_Colrfas:
    /* Code for Colrfas Goes Here */
    visitColumn_reference(_p_->u.colrfas_.column_reference_);
    visitAs(_p_->u.colrfas_.as_);
    visitIdentifier(_p_->u.colrfas_.identifier_);
    break;
  case is_Colrfin:
    /* Code for Colrfin Goes Here */
    visitIdentifier(_p_->u.colrfin_.identifier_);
    visitIn(_p_->u.colrfin_.in_);
    visitColumn_reference(_p_->u.colrfin_.column_reference_);
    break;
  case is_Colrf:
    /* Code for Colrf Goes Here */
    visitColumn_reference(_p_->u.colrf_.column_reference_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Variable_declaration!\n");
    exit(1);
  }
}

void visitOptional_where_clause(Optional_where_clause _p_)
{
  switch(_p_->kind)
  {
  case is_Nowhr:
    /* Code for Nowhr Goes Here */
    break;
  case is_Whrcls:
    /* Code for Whrcls Goes Here */
    visitWhere(_p_->u.whrcls_.where_);
    visitCondition(_p_->u.whrcls_.condition_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Optional_where_clause!\n");
    exit(1);
  }
}

void visitCondition(Condition _p_)
{
  switch(_p_->kind)
  {
  case is_Paracnd:
    /* Code for Paracnd Goes Here */
    visitCondition(_p_->u.paracnd_.condition_);
    break;
  case is_Andcnd:
    /* Code for Andcnd Goes Here */
    visitCondition(_p_->u.andcnd_.condition_1);
    visitAnd(_p_->u.andcnd_.and_);
    visitCondition(_p_->u.andcnd_.condition_2);
    break;
  case is_Orcnd:
    /* Code for Orcnd Goes Here */
    visitCondition(_p_->u.orcnd_.condition_1);
    visitOr(_p_->u.orcnd_.or_);
    visitCondition(_p_->u.orcnd_.condition_2);
    break;
  case is_Notcnd:
    /* Code for Notcnd Goes Here */
    visitNot(_p_->u.notcnd_.not_);
    visitCondition(_p_->u.notcnd_.condition_);
    break;
  case is_Predcnd:
    /* Code for Predcnd Goes Here */
    visitPredicate(_p_->u.predcnd_.predicate_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Condition!\n");
    exit(1);
  }
}

void visitPredicate(Predicate _p_)
{
  switch(_p_->kind)
  {
  case is_Comp:
    /* Code for Comp Goes Here */
    visitComparison_predicate(_p_->u.comp_.comparison_predicate_);
    break;
  case is_In:
    /* Code for In Goes Here */
    visitIn_predicate(_p_->u.in_.in_predicate_);
    break;
  case is_Exts:
    /* Code for Exts Goes Here */
    visitExists_predicate(_p_->u.exts_.exists_predicate_);
    break;
  case is_Bwn:
    /* Code for Bwn Goes Here */
    visitBetween_predicate(_p_->u.bwn_.between_predicate_);
    break;
  case is_Lik:
    /* Code for Lik Goes Here */
    visitLike_predicate(_p_->u.lik_.like_predicate_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Predicate!\n");
    exit(1);
  }
}

void visitComparison_predicate(Comparison_predicate _p_)
{
  switch(_p_->kind)
  {
  case is_CompSca:
    /* Code for CompSca Goes Here */
    visitScalar_exp(_p_->u.compsca_.scalar_exp_1);
    visitComparison(_p_->u.compsca_.comparison_);
    visitScalar_exp(_p_->u.compsca_.scalar_exp_2);
    break;
  case is_CompNst:
    /* Code for CompNst Goes Here */
    visitScalar_exp(_p_->u.compnst_.scalar_exp_);
    visitComparison(_p_->u.compnst_.comparison_);
    visitNested_query(_p_->u.compnst_.nested_query_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Comparison_predicate!\n");
    exit(1);
  }
}

void visitComparison(Comparison _p_)
{
  switch(_p_->kind)
  {
  case is_Eq:
    /* Code for Eq Goes Here */
    break;
  case is_Neq:
    /* Code for Neq Goes Here */
    break;
  case is_Lt:
    /* Code for Lt Goes Here */
    break;
  case is_Gt:
    /* Code for Gt Goes Here */
    break;
  case is_Leq:
    /* Code for Leq Goes Here */
    visitLe(_p_->u.leq_.le_);
    break;
  case is_Geq:
    /* Code for Geq Goes Here */
    visitGe(_p_->u.geq_.ge_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Comparison!\n");
    exit(1);
  }
}

void visitScalar_exp(Scalar_exp _p_)
{
  switch(_p_->kind)
  {
  case is_Atm:
    /* Code for Atm Goes Here */
    visitAtom(_p_->u.atm_.atom_);
    break;
  case is_Colrftw:
    /* Code for Colrftw Goes Here */
    visitColumn_reference(_p_->u.colrftw_.column_reference_);
    break;
  case is_Parsca:
    /* Code for Parsca Goes Here */
    visitScalar_exp(_p_->u.parsca_.scalar_exp_);
    break;
  case is_Addsca:
    /* Code for Addsca Goes Here */
    visitScalar_exp(_p_->u.addsca_.scalar_exp_1);
    visitScalar_exp(_p_->u.addsca_.scalar_exp_2);
    break;
  case is_Subsca:
    /* Code for Subsca Goes Here */
    visitScalar_exp(_p_->u.subsca_.scalar_exp_1);
    visitScalar_exp(_p_->u.subsca_.scalar_exp_2);
    break;
  case is_Mulsca:
    /* Code for Mulsca Goes Here */
    visitScalar_exp(_p_->u.mulsca_.scalar_exp_1);
    visitScalar_exp(_p_->u.mulsca_.scalar_exp_2);
    break;
  case is_Divsca:
    /* Code for Divsca Goes Here */
    visitScalar_exp(_p_->u.divsca_.scalar_exp_1);
    visitMod(_p_->u.divsca_.mod_);
    visitScalar_exp(_p_->u.divsca_.scalar_exp_2);
    break;
  case is_Andsca:
    /* Code for Andsca Goes Here */
    visitScalar_exp(_p_->u.andsca_.scalar_exp_1);
    visitScalar_exp(_p_->u.andsca_.scalar_exp_2);
    break;
  case is_Orsca:
    /* Code for Orsca Goes Here */
    visitScalar_exp(_p_->u.orsca_.scalar_exp_1);
    visitScalar_exp(_p_->u.orsca_.scalar_exp_2);
    break;
  case is_Notsca:
    /* Code for Notsca Goes Here */
    visitScalar_exp(_p_->u.notsca_.scalar_exp_1);
    visitScalar_exp(_p_->u.notsca_.scalar_exp_2);
    break;
  case is_Lssca:
    /* Code for Lssca Goes Here */
    visitScalar_exp(_p_->u.lssca_.scalar_exp_1);
    visitLs(_p_->u.lssca_.ls_);
    visitScalar_exp(_p_->u.lssca_.scalar_exp_2);
    break;
  case is_Rssca:
    /* Code for Rssca Goes Here */
    visitScalar_exp(_p_->u.rssca_.scalar_exp_1);
    visitRs(_p_->u.rssca_.rs_);
    visitScalar_exp(_p_->u.rssca_.scalar_exp_2);
    break;
  case is_Atmtw:
    /* Code for Atmtw Goes Here */
    visitAtom(_p_->u.atmtw_.atom_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Scalar_exp!\n");
    exit(1);
  }
}

void visitListAtom(ListAtom listatom)
{
  while(listatom != 0)
  {
    /* Code For ListAtom Goes Here */
    visitAtom(listatom->atom_);
    listatom = listatom->listatom_;
  }
}

void visitAtom(Atom _p_)
{
  switch(_p_->kind)
  {
  case is_Strng:
    /* Code for Strng Goes Here */
    visitString(_p_->u.strng_.string_);
    break;
  case is_Decim:
    /* Code for Decim Goes Here */
    visitDecimal(_p_->u.decim_.decimal_);
    break;
  case is_Ipadd:
    /* Code for Ipadd Goes Here */
    visitIpadr(_p_->u.ipadd_.ipadr_);
    break;
  case is_Intgr:
    /* Code for Intgr Goes Here */
    visitInteger(_p_->u.intgr_.integer_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Atom!\n");
    exit(1);
  }
}

void visitIn_predicate(In_predicate _p_)
{
  switch(_p_->kind)
  {
  case is_Innstq:
    /* Code for Innstq Goes Here */
    visitScalar_exp(_p_->u.innstq_.scalar_exp_);
    visitIn(_p_->u.innstq_.in_);
    visitNested_query(_p_->u.innstq_.nested_query_);
    break;
  case is_Inostq:
    /* Code for Inostq Goes Here */
    visitScalar_exp(_p_->u.inostq_.scalar_exp_);
    visitNot(_p_->u.inostq_.not_);
    visitIn(_p_->u.inostq_.in_);
    visitNested_query(_p_->u.inostq_.nested_query_);
    break;
  case is_Inatm:
    /* Code for Inatm Goes Here */
    visitScalar_exp(_p_->u.inatm_.scalar_exp_);
    visitIn(_p_->u.inatm_.in_);
    visitAtom(_p_->u.inatm_.atom_);
    break;
  case is_Inoatm:
    /* Code for Inoatm Goes Here */
    visitScalar_exp(_p_->u.inoatm_.scalar_exp_);
    visitNot(_p_->u.inoatm_.not_);
    visitIn(_p_->u.inoatm_.in_);
    visitAtom(_p_->u.inoatm_.atom_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing In_predicate!\n");
    exit(1);
  }
}

void visitExists_predicate(Exists_predicate _p_)
{
  switch(_p_->kind)
  {
  case is_Extnstq:
    /* Code for Extnstq Goes Here */
    visitExists(_p_->u.extnstq_.exists_);
    visitNested_query(_p_->u.extnstq_.nested_query_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Exists_predicate!\n");
    exit(1);
  }
}

void visitBetween_predicate(Between_predicate _p_)
{
  switch(_p_->kind)
  {
  case is_Bwsca:
    /* Code for Bwsca Goes Here */
    visitScalar_exp(_p_->u.bwsca_.scalar_exp_1);
    visitBetween(_p_->u.bwsca_.between_);
    visitScalar_exp(_p_->u.bwsca_.scalar_exp_2);
    visitAnd(_p_->u.bwsca_.and_);
    visitScalar_exp(_p_->u.bwsca_.scalar_exp_3);
    break;
  case is_Bwnosca:
    /* Code for Bwnosca Goes Here */
    visitScalar_exp(_p_->u.bwnosca_.scalar_exp_1);
    visitNot(_p_->u.bwnosca_.not_);
    visitBetween(_p_->u.bwnosca_.between_);
    visitScalar_exp(_p_->u.bwnosca_.scalar_exp_2);
    visitAnd(_p_->u.bwnosca_.and_);
    visitScalar_exp(_p_->u.bwnosca_.scalar_exp_3);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Between_predicate!\n");
    exit(1);
  }
}

void visitLike_predicate(Like_predicate _p_)
{
  switch(_p_->kind)
  {
  case is_Lkstr:
    /* Code for Lkstr Goes Here */
    visitScalar_exp(_p_->u.lkstr_.scalar_exp_);
    visitLike(_p_->u.lkstr_.like_);
    visitString(_p_->u.lkstr_.string_);
    break;
  case is_Lknostr:
    /* Code for Lknostr Goes Here */
    visitScalar_exp(_p_->u.lknostr_.scalar_exp_);
    visitNot(_p_->u.lknostr_.not_);
    visitLike(_p_->u.lknostr_.like_);
    visitString(_p_->u.lknostr_.string_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Like_predicate!\n");
    exit(1);
  }
}

void visitOptional_order_by_clause(Optional_order_by_clause _p_)
{
  switch(_p_->kind)
  {
  case is_Nordby:
    /* Code for Nordby Goes Here */
    break;
  case is_Ordby:
    /* Code for Ordby Goes Here */
    visitOrder(_p_->u.ordby_.order_);
    visitBy(_p_->u.ordby_.by_);
    visitColumn_reference(_p_->u.ordby_.column_reference_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Optional_order_by_clause!\n");
    exit(1);
  }
}

void visitListColumn_reference(ListColumn_reference listcolumn_reference)
{
  while(listcolumn_reference != 0)
  {
    /* Code For ListColumn_reference Goes Here */
    visitColumn_reference(listcolumn_reference->column_reference_);
    listcolumn_reference = listcolumn_reference->listcolumn_reference_;
  }
}

void visitOptional_group_by_clause(Optional_group_by_clause _p_)
{
  switch(_p_->kind)
  {
  case is_Nogrp:
    /* Code for Nogrp Goes Here */
    break;
  case is_Grpby:
    /* Code for Grpby Goes Here */
    visitGroup(_p_->u.grpby_.group_);
    visitBy(_p_->u.grpby_.by_);
    visitColumn_reference(_p_->u.grpby_.column_reference_);
    visitOptional_ordering(_p_->u.grpby_.optional_ordering_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Optional_group_by_clause!\n");
    exit(1);
  }
}

void visitOptional_ordering(Optional_ordering _p_)
{
  switch(_p_->kind)
  {
  case is_Nord:
    /* Code for Nord Goes Here */
    break;
  case is_Ordasc:
    /* Code for Ordasc Goes Here */
    visitAsc(_p_->u.ordasc_.asc_);
    break;
  case is_Orddsc:
    /* Code for Orddsc Goes Here */
    visitDesc(_p_->u.orddsc_.desc_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Optional_ordering!\n");
    exit(1);
  }
}

void visitOptional_having_clause(Optional_having_clause _p_)
{
  switch(_p_->kind)
  {
  case is_Nohvin:
    /* Code for Nohvin Goes Here */
    break;
  case is_Hvin:
    /* Code for Hvin Goes Here */
    visitHaving(_p_->u.hvin_.having_);
    visitAggregate_condition(_p_->u.hvin_.aggregate_condition_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Optional_having_clause!\n");
    exit(1);
  }
}

void visitAggregate_condition(Aggregate_condition _p_)
{
  switch(_p_->kind)
  {
  case is_Aggr:
    /* Code for Aggr Goes Here */
    visitFunction_reference(_p_->u.aggr_.function_reference_);
    visitComparison(_p_->u.aggr_.comparison_);
    visitScalar_exp(_p_->u.aggr_.scalar_exp_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Aggregate_condition!\n");
    exit(1);
  }
}

void visitFunction_reference(Function_reference _p_)
{
  switch(_p_->kind)
  {
  case is_Funstr:
    /* Code for Funstr Goes Here */
    visitFunction(_p_->u.funstr_.function_);
    break;
  case is_Fundist:
    /* Code for Fundist Goes Here */
    visitFunction(_p_->u.fundist_.function_);
    visitDistinct(_p_->u.fundist_.distinct_);
    visitColumn_reference(_p_->u.fundist_.column_reference_);
    break;
  case is_Funsca:
    /* Code for Funsca Goes Here */
    visitFunction(_p_->u.funsca_.function_);
    visitScalar_exp(_p_->u.funsca_.scalar_exp_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Function_reference!\n");
    exit(1);
  }
}

void visitFunction(Function _p_)
{
  switch(_p_->kind)
  {
  case is_Sum:
    /* Code for Sum Goes Here */
    visitSum(_p_->u.sum_.sum_);
    break;
  case is_Avg:
    /* Code for Avg Goes Here */
    visitAvg(_p_->u.avg_.avg_);
    break;
  case is_Count:
    /* Code for Count Goes Here */
    visitCount(_p_->u.count_.count_);
    break;
  case is_Max:
    /* Code for Max Goes Here */
    visitMax(_p_->u.max_.max_);
    break;
  case is_Min:
    /* Code for Min Goes Here */
    visitMin(_p_->u.min_.min_);
    break;

  default:
    fprintf(stderr, "Error: bad kind field when printing Function!\n");
    exit(1);
  }
}

void visitSelect(SELECT p)
{
  /* Code for SELECT Goes Here */
}
void visitFrom(FROM p)
{
  /* Code for FROM Goes Here */
}
void visitWhere(WHERE p)
{
  /* Code for WHERE Goes Here */
}
void visitPointer(POINTER p)
{
  /* Code for POINTER Goes Here */
}
void visitAnd(AND p)
{
  /* Code for AND Goes Here */
}
void visitNot(NOT p)
{
  /* Code for NOT Goes Here */
}
void visitOr(OR p)
{
  /* Code for OR Goes Here */
}
void visitBetween(BETWEEN p)
{
  /* Code for BETWEEN Goes Here */
}
void visitNil(NIL p)
{
  /* Code for NIL Goes Here */
}
void visitExists(EXISTS p)
{
  /* Code for EXISTS Goes Here */
}
void visitLike(LIKE p)
{
  /* Code for LIKE Goes Here */
}
void visitIn(IN p)
{
  /* Code for IN Goes Here */
}
void visitInteger(INTEGER p)
{
  /* Code for INTEGER Goes Here */
}
void visitIpadr(IPADR p)
{
  /* Code for IPADR Goes Here */
}
void visitDecimal(DECIMAL p)
{
  /* Code for DECIMAL Goes Here */
}
void visitDistinct(DISTINCT p)
{
  /* Code for DISTINCT Goes Here */
}
void visitAs(AS p)
{
  /* Code for AS Goes Here */
}
void visitMod(MOD p)
{
  /* Code for MOD Goes Here */
}
void visitGroup(GROUP p)
{
  /* Code for GROUP Goes Here */
}
void visitBy(BY p)
{
  /* Code for BY Goes Here */
}
void visitHaving(HAVING p)
{
  /* Code for HAVING Goes Here */
}
void visitOrder(ORDER p)
{
  /* Code for ORDER Goes Here */
}
void visitAsc(ASC p)
{
  /* Code for ASC Goes Here */
}
void visitDesc(DESC p)
{
  /* Code for DESC Goes Here */
}
void visitCount(COUNT p)
{
  /* Code for COUNT Goes Here */
}
void visitSum(SUM p)
{
  /* Code for SUM Goes Here */
}
void visitAvg(AVG p)
{
  /* Code for AVG Goes Here */
}
void visitMax(MAX p)
{
  /* Code for MAX Goes Here */
}
void visitMin(MIN p)
{
  /* Code for MIN Goes Here */
}
void visitLe(LE p)
{
  /* Code for LE Goes Here */
}
void visitGe(GE p)
{
  /* Code for GE Goes Here */
}
void visitRs(RS p)
{
  /* Code for RS Goes Here */
}
void visitLs(LS p)
{
  /* Code for LS Goes Here */
}
void visitNe(NE p)
{
  /* Code for NE Goes Here */
}
void visitInvalid(INVALID p)
{
  /* Code for INVALID Goes Here */
}
void visitIdentifier(IDENTIFIER p)
{
  /* Code for IDENTIFIER Goes Here */
}
void visitSc(SC p)
{
  /* Code for SC Goes Here */
}
void visitIdent(Ident i)
{
  /* Code for Ident Goes Here */
}
void visitInteger(Integer i)
{
  /* Code for Integer Goes Here */
}
void visitDouble(Double d)
{
  /* Code for Double Goes Here */
}
void visitChar(Char c)
{
  /* Code for Char Goes Here */
}
void visitString(String s)
{
  /* Code for String Goes Here */
}

